#include <iostream>
// 桥接模式：结构型设计模式 将抽象部分与实现部分 分离，使他们可以独立变化
// 优点：松耦合、灵活性、避免多重继承
// 实现步骤：1、提供一个抽象类(桥接类):提供高层控制逻辑，依赖实际底层对象
//         2、提供一个具体抽象类：拓展抽象类，更精确的抽象
//         3、提供具体实现抽象类：具体实现类的抽象通用接口
//         4、提供具体实现类：针对不同底层的通用接口实现

// 实现化角色接口
class Implementor {
    public:
    virtual ~Implementor() {}
    virtual void operationImpl() = 0; // 定义操作接口
};

// 具体实现化角色A
class ConcreteImplementorA : public Implementor {
    public:
    void operationImpl() {
        std::cout << "ConcreteImplementorA 的 operationImpl()" << std::endl;
    }
};

// 具体实现化角色B
class ConcreteImplementorB : public Implementor {
    public:
    void operationImpl() {
        std::cout << "ConcreteImplementorB 的 operationImpl()" << std::endl;
    }
};

// 抽象化角色
class Abstraction {
    protected:
    Implementor* implementor_;
    public:
    Abstraction(Implementor* impl):implementor_(impl) {}
    virtual ~Abstraction() {delete implementor_;}
    virtual void operation() = 0; // 定义抽象操作
};

//具体抽象化角色
class RefineAbstraction : public Abstraction {
    public:
    RefineAbstraction(Implementor* impl) : Abstraction(impl) {} 

    virtual void operation() {
        std::cout << "RefineAbstraction 调用 operation..." << std::endl;
        implementor_->operationImpl(); // 委托实现化角色执行操作    
        }
};

int main () {
    std::cout << "hello Brige pattern!!!" << std::endl;
    Abstraction* absA = new RefineAbstraction(new ConcreteImplementorA());
    absA->operation();

    Abstraction* absB = new RefineAbstraction(new ConcreteImplementorB());
    absB->operation();

    delete absA;
    delete absB;

    return 0;
}